import pandas as pd
import numpy as np
import datetime as datetime
import warnings
import openpyxl
from openpyxl import load_workbook

import xlrd
import xlwt


# print(read)
def concatAll():

    # print(read)
    下载文件路径字典 = {   '工伤保险':['../文件/合肥/工伤保险2024-09-041.xlsx','../文件/合肥/工伤保险2024-09-042.xlsx'],
                        '职工基本养老保险(单位缴纳)': [
                            '../文件/合肥/职工基本养老保险(单位缴纳)2024-03-251711351834.xls',
                            '../文件/合肥/职工基本养老保险(单位缴纳)2024-03-251711351845.xls']}
    社保数据中间表 = '../文件/合肥/test.xlsx'
    pd.set_option('display.max_columns', None)
    warnings.filterwarnings('ignore')
    # 设置一个空的dateframe
    allResultDate = pd.DataFrame({'姓名': [], '证件号码': []})
    for key, value in 下载文件路径字典.items():
        print(f'本次运行的文件路径为：{value}')
        if len(value) >= 2:
            # 根据 'key' 列合并两个 DataFrame
            readDateList = []
            for item in value:
                print(item)
                # pd.read_excel('../文件/合肥/工伤保险2024-09-041.xlsx')
                readDate = pd.read_excel(item)
                readDateList.append(readDate)
            concatDate = pd.concat(readDateList, axis=0)
            # 将证件号码，这一列的类型装换为str 类型，才可以用groupby进行分组求和
            concatDate['证件号码'] = concatDate['证件号码'].astype(str)
            # 根据证件号码进行分组求和 as_index
            # itemDateframe = concatDate.groupby('证件号码', as_index=False).agg(itemHeadMap)
            concatDate['应缴费额'] = concatDate.groupby('证件号码')['应缴费额'].transform('sum')
            print(concatDate)
            # 如果需要，可以删除重复的'A'列值
            concatDate.drop_duplicates(subset='证件号码', inplace=True)
            itemDateframe = concatDate.reset_index(drop=True).fillna('')
        else:
            itemDateframe = pd.read_excel(value[0])
            itemDateframe['证件号码'] = itemDateframe['证件号码'].astype(str)
        resultDateframe = itemDateframe[['姓名', '证件号码', '缴费基数', '应缴费额']]
        resultDateframe.rename(columns={'缴费基数': key + '缴费基数', '应缴费额': key + '应缴费额'}, inplace=True)
        # print(resultDateframe)
        # allResultDateList.append(resultDateframe)
        allResultDate = pd.merge(allResultDate, resultDateframe, how='outer', on=['姓名', '证件号码'])
    # print(allResultDate)
    allResultDate.fillna(0,inplace=True)
    allResultDate.to_excel(社保数据中间表)
    # return allResultDate


concatAll()


def dataDoing():
    社保数据接口数据 = '../文件/合肥/下载社保数据接口数据2024-03-26.xls'
    社保数据中间表 = '../文件/合肥/test.xlsx'
    pd.set_option('display.max_columns', None)
    warnings.filterwarnings('ignore')
    # 以 {保险种类:{数据接口模板表头字段 : 在缴数据对应表头字段}} 做成类似的对应字典
    headMap = {'工伤保险单位交': '工伤保险应缴费额', '养老保险单位交': '职工基本养老保险(单位缴纳)应缴费额',
               '养老保险个人交': '职工基本养老保险(个人缴纳)应缴费额', '失业保险单位交': '失业保险(单位缴纳)应缴费额',
               '失业保险个人交': '失业保险(个人缴纳)应缴费额', '医疗保险单位交': '职工基本医疗保险(单位缴纳)应缴费额',
               '医疗保险个人交': '职工基本医疗保险(个人缴纳)应缴费额'}
    # 社保险种列表 = ['失业保险(单位缴纳)', '失业保险(个人缴纳)', '职工基本养老保险(单位缴纳)',
    #                 '职工基本养老保险(个人缴纳)', '工伤保险']

    itemDateframe = pd.read_excel(社保数据中间表, dtype={'证件号码': str})
    # print(itemDateframe)

    ###########################################################
    # 将读取的姓名数据转成列表,

    readExcelList = itemDateframe['证件号码'].values.tolist()
    print(f'本次读取的身份证号有:{readExcelList}')
    # 读取社保数据接口表中的数据
    readInterfaceExcel = pd.read_excel(社保数据接口数据, dtype={'证件号码': str, '人员编码': str, '员工号': str})

    readInterfaceExcel['证件号码'] = readInterfaceExcel['证件号码'].astype(str)
    heardList = readInterfaceExcel.columns.tolist()
    print(f'当前数据接口模板表的表头为{heardList}')
    # 匹配出社保数据接口中证件号码包含在readExcelList中的数据
    readInterfaceDate = readInterfaceExcel[readInterfaceExcel['证件号码'].isin(readExcelList)]
    print(f'匹配身份证后的数据为{readInterfaceDate}')

    # 合并两个数据列表,并通过表头字段head ,获取其中需要的几列
    mergeDate = pd.merge(readInterfaceDate, itemDateframe, how='inner', on=['证件号码'])
    print("*****************")
    # 社保医保个人、单位缴交费用计算
    for i in range(0, mergeDate.shape[0]):
        for headKey, headValue in headMap.items():
            mergeDate.loc[i, headKey] = mergeDate.loc[i, headValue]  # 覆盖headMap中对应的列
        # 所有的计算完毕后，进行汇总社保单位、个人合计
        # mergeDate.loc[i, '社保单位合计'] = mergeDate.loc[i, '工伤保险单位交'] + \
        #                                    mergeDate.loc[i, '养老保险单位交'] + \
        #                                    mergeDate.loc[i, '失业保险单位交']
        #
        # mergeDate.loc[i, '社保个人合计'] = mergeDate.loc[i, '养老保险个人交'] + \
        #                                    mergeDate.loc[i, '失业保险个人交']
        mergeDate.loc[i, '社保单位合计'] = mergeDate.loc[i, '工伤保险单位交'] + \
                                           mergeDate.loc[i, '养老保险单位交'] + \
                                           mergeDate.loc[i, '失业保险单位交'] + \
                                           mergeDate.loc[i, '医疗保险单位交']

        mergeDate.loc[i, '社保个人合计'] = mergeDate.loc[i, '养老保险个人交'] + \
                                           mergeDate.loc[i, '失业保险个人交'] + \
                                           mergeDate.loc[i, '医疗保险个人交']
    # 获取其中需要的表头数据
    resultDate = mergeDate[heardList]
    print(resultDate)

    # # 将获取所需要的表头后的数据转化为列表
    resultDateList = resultDate.values.tolist()
    print(f'将匹配后的数据转换成列表{resultDateList}')
    # # 获取其中的行数,并将所有行数加1
    indexList = readInterfaceDate.index.tolist()
    for i in range(0, len(indexList)):
        indexList[i] = indexList[i] + 1
    print(f'处理后的行数列表{indexList}')
    # 打开xls文件，并在指定行中写入文件
    workbook = xlrd.open_workbook(社保数据接口数据)  # xlrd打开excel
    sheet = workbook.sheet_by_index(0)
    wb = xlwt.Workbook(encoding='utf-8')  # lxwt新建一个sheet页
    new_sheet = wb.add_sheet(sheet.name)
    for row_index in range(sheet.nrows):  # 循环每一行
        row = sheet.row_values(row_index)  # 旧数据中每一行的值
        if row_index in indexList:  # 如果行号与之前存储的匹配数据行列表中的值相同
            index = indexList.index(row_index)
            # 写入新数据到新的sheet
            for col_index, value in enumerate(resultDateList[index]):
                if str(value) == 'nan':
                    value = ''
                new_sheet.write(row_index, col_index, str(value))
            print(f'在{row_index}行中写入新数据:{resultDateList[index]}')
        else:
            # 写入旧数据到新的sheet
            for col_index, value in enumerate(row):
                new_sheet.write(row_index, col_index, value)
    wb.save(社保数据接口数据)


# dataDoing()


def readUser():
    用户配置表 = '../文件/社保用户配置表.xlsx'
    userdate = pd.read_excel(用户配置表, dtype='str')
    print(userdate)
    社保用户数据 = userdate.values.tolist()
    print(社保用户数据)
    time = datetime.datetime.now().strftime('%Y-%m-%d')
    print(time)


'''
#弃用，改为上面的方式实现
def dataDoing1(): 
    社保数据接口数据 = '../文件/合肥/下载社保数据接口数据2024-03-26.xls'

    下载文件路径字典 = {'工伤保险': ['../文件/合肥/工伤保险2024-03-251711351845.xls'],
                        '职工基本养老保险(单位缴纳)': [
                            '../文件/合肥/职工基本养老保险(单位缴纳)2024-03-251711351834.xls',
                            '../文件/合肥/职工基本养老保险(单位缴纳)2024-03-251711351845.xls']}

    pd.set_option('display.max_columns', None)
    warnings.filterwarnings('ignore')
    # 以 {保险种类:{数据接口模板表头字段 : 在缴数据对应表头字段}} 做成类似的对应字典
    headMap = {'工伤保险': {'工伤保险单位交': '应缴费额'},
               '职工基本养老保险(单位缴纳)': {'养老保险单位交': '应缴费额'},
               '职工基本养老保险(个人缴纳)': {'养老保险个人交': '应缴费额'},
               '失业保险(单位缴纳)': {'失业保险单位交': '应缴费额'},
               '失业保险(个人缴纳)': {'失业保险个人交': '应缴费额'},
               '职工基本医疗保险(单位缴纳)': {'医疗保险单位交': '应缴费额'},
               '职工基本医疗保险(个人缴纳)': {'医疗保险个人交': '应缴费额'}}

    for key, value in 下载文件路径字典.items():
        print(f'本次运行的文件路径为：{value}')
        if len(value) >= 2:
            # 根据 'key' 列合并两个 DataFrame
            readDateList = []
            for item in value:
                readDate = pd.read_excel(item)
                readDateList.append(readDate)

            concatDate = pd.concat(readDateList, axis=0)

            # print(concatDate)
            # concatDateHead = concatDate.columns.tolist()

            # 构建表头的map   {'表头':'first','应缴费用':'sum'}, 即其他表头取分组后的第一个值,应缴费用就取分组后求和
            # itemHeadMap = {'序号': 'first', '姓名': 'first', '证件类型': 'first', '证件号码': 'first',
            #                '缴费工资': 'first', '缴费基数': 'first', '费率': 'first', '应缴费额': 'sum',
            #                '人员编号': 'first'}
            # itemHeadMap = {}
            # for head in concatDateHead:
            #     if head == '应缴费额':
            #         itemHeadMap[head] = 'sum'
            #         continue
            #     itemHeadMap[head] = 'first'
            # print(itemHeadMap)
            # 将证件号码，这一列的类型装换为str 类型，才可以用groupby进行分组求和
            concatDate['证件号码'] = concatDate['证件号码'].astype(str)
            # 根据证件号码进行分组求和 as_index
            # itemDateframe = concatDate.groupby('证件号码', as_index=False).agg(itemHeadMap)
            concatDate['应缴费额'] = concatDate.groupby('证件号码')['应缴费额'].transform('sum')
            print(concatDate)
            # 如果需要，可以删除重复的'A'列值
            concatDate.drop_duplicates(subset='证件号码', inplace=True)
            itemDateframe = concatDate.reset_index(drop=True).fillna('')
            print(itemDateframe)
        else:
            itemDateframe = pd.read_excel(value[0])
        # print(itemDateframe)

        ###########################################################
        # 将读取的姓名数据转成列表,

        readExcelList = itemDateframe['证件号码'].values.tolist()
        print(f'本次读取的身份证号有:{readExcelList}')
        # 读取社保数据接口表中的数据
        readInterfaceExcel = pd.read_excel(社保数据接口数据)

        # readInterfaceExcel['证件号码'] = readInterfaceExcel['证件号码'].astype(str)
        heardList = readInterfaceExcel.columns.tolist()
        print(f'当前数据接口模板表的表头为{heardList}')
        # 匹配出社保数据接口中证件号码包含在readExcelList中的数据
        readInterfaceDate = readInterfaceExcel[readInterfaceExcel['证件号码'].isin(readExcelList)]
        print(f'匹配身份证后的数据为{readInterfaceDate}')

        # 合并两个数据列表,并通过表头字段head ,获取其中需要的几列
        mergeDate = pd.merge(readInterfaceDate, itemDateframe, how='inner', on=['证件号码'])
        print("*****************")
        # 社保医保个人、单位缴交费用计算
        for i in range(0, mergeDate.shape[0]):
            for headKey, headValue in headMap[key].items():
                mergeDate.loc[i, headKey] = mergeDate.loc[i, headValue]  # 覆盖headMap中对应的列
            # 所有的计算完毕后，进行汇总社保单位、个人合计
            mergeDate.loc[i, '社保单位合计'] = mergeDate.loc[i, '工伤保险单位交'] + \
                                               mergeDate.loc[i, '养老保险单位交'] + \
                                               mergeDate.loc[i, '失业保险单位交'] + \
                                               mergeDate.loc[i, '医疗保险单位交']

            mergeDate.loc[i, '社保个人合计'] = mergeDate.loc[i, '养老保险个人交'] + \
                                               mergeDate.loc[i, '失业保险个人交'] + \
                                               mergeDate.loc[i, '医疗保险个人交']
        # 获取其中需要的表头数据
        resultDate = mergeDate[heardList]
        print(resultDate)

        # # 将获取所需要的表头后的数据转化为列表
        resultDateList = resultDate.values.tolist()
        print(f'将匹配后的数据转换成列表{resultDateList}')
        # # 获取其中的行数,并将所有行数加1
        indexList = readInterfaceDate.index.tolist()
        for i in range(0, len(indexList)):
            indexList[i] = indexList[i] + 1
        print(f'处理后的行数列表{indexList}')
        # 打开xls文件，并在指定行中写入文件
        workbook = xlrd.open_workbook(社保数据接口数据)  # xlrd打开excel
        sheet = workbook.sheet_by_index(0)
        wb = xlwt.Workbook(encoding='utf-8')  # lxwt新建一个sheet页
        new_sheet = wb.add_sheet(sheet.name)
        for row_index in range(sheet.nrows):  # 循环每一行
            row = sheet.row_values(row_index)  # 旧数据中每一行的值
            if row_index in indexList:  # 如果行号与之前存储的匹配数据行列表中的值相同
                index = indexList.index(row_index)
                # 写入新数据到新的sheet
                for col_index, value in enumerate(resultDateList[index]):
                    if str(value) == 'nan':
                        value = ''
                    new_sheet.write(row_index, col_index, str(value))
                print(f'在{row_index}行中写入新数据:{resultDateList[index]}')
            else:
                # 写入旧数据到新的sheet
                for col_index, value in enumerate(row):
                    new_sheet.write(row_index, col_index, value)
        wb.save(社保数据接口数据)


# dataDoing()
'''


def addOther():
    # 将其他的特殊人员写入到表格中
    社保数据接口数据 = '../文件/下载社保数据接口数据2024-03-26.xls'
    特殊在保人员文件路径 = '../文件/特殊社保在保人员.xls'
    warnings.filterwarnings('ignore')
    readDate = pd.read_excel(社保数据接口数据)
    readOtherDate = pd.read_excel(特殊在保人员文件路径)
    lenth = len(readOtherDate)

    if (lenth > 0):
        concatDate = pd.concat([readDate, readOtherDate], axis=0)
        print('特殊在保人员文件中数据不为空,拼接特殊人员数据')
    else:
        concatDate = readDate
        # Log.Info('特殊在保人员文件中数据为空,没有特殊人员往下执行')
        print('特殊在保人员文件中数据为空,没有特殊人员往下执行')
    # 拼接特殊在保人员的数据
    concatDateHead = concatDate.columns.tolist()
    pd.set_option('display.max_columns', None)
    # 设置groupby后的计算规则

    # 将证件号码，这一列的类型装换为str 类型，才可以用groupby进行分组求和
    concatDate['证件号码'] = concatDate['证件号码'].astype(str)
    # # 根据证件号码进行分组求和 as_index
    headFirst = ['员工号', '人员姓名', '证件号码', '人员编码']  # 设置一下数据不用变 的表头用来区分‘first’和‘max’
    for head in concatDateHead:
        if head in headFirst:
            concatDate[head] = concatDate.groupby('证件号码')[head].transform('first')
        else:
            concatDate[head] = concatDate.groupby('证件号码')[head].transform('max')
    print(concatDate)
    # 如果需要，可以删除重复的'A'列值
    concatDate.drop_duplicates(subset='证件号码', inplace=True)
    itemDateframe = concatDate.reset_index(drop=True).fillna('')
    # 所有结果做保留两位有效数字处理
    colList = itemDateframe.columns.tolist()
    nameList = ['社保应收合计', '社保个人合计', '社保单位合计', '养老保险缴费基数', '养老保险个人交', '养老保险单位交',
                '医疗保险缴费基数', '医疗保险个人交', '医疗保险单位交', '工伤保险缴费基数', '工伤保险单位交',
                '失业保险缴费基数', '失业保险个人交', '失业保险单位交', '生育医疗缴费基数', '生育医疗单位交',
                '大病医疗单位', '大病医疗个人', '社保代扣', '公积金缴存基数（元）', '公积金单位缴存比例',
                '公积金个人缴存比例', '公积金单位缴费', '公积金个人缴费', '公积金金额合计（元）', '公积金代扣']

    for name in colList:
        if name in nameList:
            itemDateframe[name] = itemDateframe[name].map(lambda x: round(x, 2))
    Log.Info(self, itemDateframe)
    # itemDateframe.fillna('')
    print(itemDateframe)
    # 写入.xls文件
    wb = xlwt.Workbook(encoding='utf-8')  # lxwt新建一个sheet页
    #    new_sheet = wb.add_sheet(sheet.name)
    sheet = wb.add_sheet('Sheet0')
    # 将DataFrame的列名写入Excel表头
    for i, col_name in enumerate(itemDateframe.columns):
        sheet.write(0, i, col_name)
    # 将DataFrame的数据写入Excel
    for i, row in itemDateframe.iterrows():
        for j, col in enumerate(row):
            sheet.write(i + 1, j, col)
    wb.save(社保数据接口数据)


def chuli():
    用户配置表 = '../文件/社保用户配置表.xlsx'
    list = ['120223197912152512', '41148119860611092X', '42058219801208275X', '420582198406072765',
            '420822198410015755', '431003198607201316', '452324198109140357']
    # 打开Excel文件
    workbook = openpyxl.load_workbook(用户配置表)
    # 选择要写入数据的表格
    sheet = workbook.active
    # 指定要写入数据的行和列
    row = 4
    column = 1
    # 写入数据
    sheet.cell(row=row, column=column, value=list)
    # 保存Excel文件
    workbook.save(用户配置表)


# chuli()

'''
# 核对数据接口数据是否正确,,,弃用,改为下面的方式实现
def checkDate():
    下载数据接口核对数据 = '../文件/合肥/下载社保数据接口数据2024-03-26.xls'
    特殊在保人员文件路径 = '../文件/合肥/特殊社保在保人员.xls'
    核对结果文件路径 = '../文件/合肥/核对结果.xlsx'
    pd.set_option('display.max_columns', None)
    下载文件路径字典 = {'工伤保险': ['../文件/合肥/工伤保险2024-03-251711351845.xls'],
                        '职工基本养老保险(单位缴纳)': [
                            '../文件/合肥/职工基本养老保险(单位缴纳)2024-03-251711351834.xls',
                            '../文件/合肥/职工基本养老保险(单位缴纳)2024-03-251711351845.xls']
                        }

    warnings.filterwarnings('ignore')
    str_datemap = {'人员编码': str, '证件号码': str}  # 设置一些读取excel时读取为str类型的数据

    readInterfaceExcel = pd.read_excel(下载数据接口核对数据, usecols='A:L', dtype=str_datemap)
    print(f'本次下载的数据接口核对数据有{len(readInterfaceExcel)}条')
    readOtherExcel = pd.read_excel(特殊在保人员文件路径, usecols='A:L', dtype=str_datemap)
    print(f'本次属于特殊人员的数据有{len(readOtherExcel)}条')

    lenth = len(readOtherExcel)
    if (lenth > 0):
        readInterfaceExcel = pd.concat([readInterfaceExcel, readOtherExcel], axis=0)
        print('特殊在保人员文件中数据不为空,拼接特殊人员数据')
    # 拼接特殊人员表后,如果两行全部数据都想相同的,就去除一行
    readDate = readInterfaceExcel.drop_duplicates(keep='first')
    # print(readDate)
    resultDateList = []
    number = 0
    mergeAllDate = None
    str_datemap1 = {'姓名': str, '证件号码': str}
    for key, value in 下载文件路径字典.items():
        number += 1
        if len(value) >= 2:
            # 根据 'key' 列合并两个 DataFrame
            readDateList = []
            for item in value:
                readitemDate = pd.read_excel(item, dtype=str_datemap1)
                readDateList.append(readitemDate)

            concatDate = pd.concat(readDateList, axis=0)
            concatDate['证件号码'] = concatDate['证件号码'].astype(str)
            # 根据证件号码进行分组求和 as_index
            concatDate['应缴费额'] = concatDate.groupby('证件号码')['应缴费额'].transform('sum')
            # print(concatDate)
            # 如果需要，可以删除重复的'A'列值
            concatDate.drop_duplicates(subset='证件号码', inplace=True)
            itemDateframe = concatDate.reset_index(drop=True).fillna(0)  # 重置index并用''填充nan
            # print(itemDateframe)
        else:
            itemDateframe = pd.read_excel(value[0], dtype=str_datemap1)
            itemDateframe = itemDateframe.fillna(0)

        columnsname = {'应缴费额': key}
        itemDateframe.rename(columns=columnsname, inplace=True)
        itemDateframe = itemDateframe[['姓名', '证件号码', key]]
        if (number >= 2):
            mergeAllDate = pd.merge(mergeAllDate, itemDateframe, how='outer', on=['证件号码', '姓名'])
        else:
            mergeAllDate = itemDateframe
        resultDateList.append(columnsname)
    # print(mergeAllDate)
    # mergeAllDate.to_excel(核对结果文件路径)
    mergeAllDate = mergeAllDate.fillna(0)
    print(f'本次属于在缴人员的数据有{len(mergeAllDate)}条')
    # print(caoncatDate)
    mergeDate = pd.merge(readDate, mergeAllDate, how='outer', on=['证件号码'])

    # 可以根据需要添加更多列对(需要相互比较的列明)
    column_pairs = [('工伤保险单位交', '工伤保险'), ('养老保险单位交', '职工基本养老保险(单位缴纳)'),
                    ('养老保险个人交', '职工基本养老保险(个人缴纳)'), ('医疗保险个人交', '职工基本医疗保险(个人缴纳)'),
                    ('医疗保险单位交', '职工基本医疗保险(单位缴纳)')
        , ('失业保险个人交', '失业保险(个人缴纳)'), ('失业保险单位交', '失业保险(单位缴纳)')]

    # 使用列表解析来创建条件 判断是否相等,不相等的为ture ,相等的为false
    conditions = [mergeDate[col1] != mergeDate[col2] for col1, col2 in column_pairs]
    # print(conditions)
    # # 使用any函数来检查任何条件是否为True、
    mask = pd.concat(conditions, axis=1).any(axis=1)
    #
    # # 使用布尔mask来筛选行
    filtered_df = mergeDate[mask]
    print(f'得到下载数据与缴交数据不相同的数据有{len(filtered_df)}条')
    filtered_df.to_excel(核对结果文件路径)

# checkDate()
'''


# 核对数据接口数据是否正确
def checkDate():
    下载数据接口核对数据 = '../文件/合肥/2024-05-20/苏州810B 社保明细.xls'
    特殊在保人员文件路径 = '../文件/合肥/2024-05-20/特殊社保在保人员.xls'
    社保数据中间表 = '../文件/苏州/test.xlsx'
    核对结果文件路径 = '../文件/苏州/核对结果.xlsx'
    pd.set_option('display.max_columns', None)

    warnings.filterwarnings('ignore')
    str_datemap = {'人员编码': str, '证件号码': str}  # 设置一些读取excel时读取为str类型的数据

    readInterfaceExcel = pd.read_excel(下载数据接口核对数据, usecols='A:L', dtype=str_datemap)
    print(f'本次下载的数据接口核对数据有{len(readInterfaceExcel)}条')
    readOtherExcel = pd.read_excel(特殊在保人员文件路径, usecols='A:L', dtype=str_datemap, sheet_name='社保特殊人员')
    print(f'本次属于特殊人员的数据有{len(readOtherExcel)}条')

    lenth = len(readOtherExcel)
    if (lenth > 0):
        readInterfaceExcel = pd.concat([readInterfaceExcel, readOtherExcel], axis=0)
        print('特殊在保人员文件中数据不为空,拼接特殊人员数据')
    # 拼接特殊人员表后,如果两行全部数据都想相同的,就去除一行
    readDate = readInterfaceExcel.drop_duplicates(keep=False)
    # print(readDate)
    resultDateList = []
    number = 0
    mergeAllDate = None
    str_datemap1 = {'姓名': str, '证件号码': str}

    itemDateframe = pd.read_excel(社保数据中间表, dtype=str_datemap1)
    itemDateframe = itemDateframe.fillna(0)

    #
    # itemDateframe.rename(columns=columnsname, inplace=True)
    # itemDateframe = itemDateframe[['姓名', '证件号码', key]]
    #
    heard = ['姓名', '证件号码', '工伤保险应缴费额', '职工基本养老保险(单位缴纳)缴费基数',
             '职工基本养老保险(个人缴纳)应缴费额',
             '职工基本养老保险(单位缴纳)应缴费额', '职工基本医疗保险(单位缴纳)应缴费额',
             '职工基本医疗保险(个人缴纳)应缴费额', '失业保险(单位缴纳)应缴费额', '失业保险(个人缴纳)应缴费额', ]
    mergeAllDate = itemDateframe[heard]
    # resultDateList.append(columnsname)
    # print(mergeAllDate)
    # mergeAllDate.to_excel(核对结果文件路径)
    # mergeAllDate = mergeAllDate.fillna(0)
    print(f'本次属于在缴人员的数据有{len(mergeAllDate)}条')
    # print(caoncatDate)
    mergeDate = pd.merge(readDate, mergeAllDate, how='outer', on=['证件号码'])

    # 可以根据需要添加更多列对(需要相互比较的列明)

    column_pairs = [('工伤保险单位交', '工伤保险应缴费额'), ('养老保险单位交', '职工基本养老保险(单位缴纳)应缴费额'),
                    ('养老保险个人交', '职工基本养老保险(个人缴纳)应缴费额'),
                    ('医疗保险单位交', '职工基本医疗保险(单位缴纳)应缴费额'),
                    ('医疗保险个人交', '职工基本医疗保险(个人缴纳)应缴费额'),
                    ('失业保险单位交', '失业保险(单位缴纳)应缴费额'),
                    ('失业保险个人交', '失业保险(个人缴纳)应缴费额')]

    # 使用列表解析来创建条件 判断是否相等,不相等的为ture ,相等的为false
    conditions = [mergeDate[col1] != mergeDate[col2] for col1, col2 in column_pairs]
    # print(conditions)
    # # 使用any函数来检查任何条件是否为True、
    mask = pd.concat(conditions, axis=1).any(axis=1)
    #
    # # 使用布尔mask来筛选行
    filtered_df = mergeDate[mask]
    print(f'得到下载数据与缴交数据不相同的数据有{len(filtered_df)}条')
    filtered_df.to_excel(核对结果文件路径)


# checkDate()
